home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 June / Macworld (1999-06).dmg / Shareware World / Info / For Developers / MacZoop2.0.sea / MacZoop2.0 / Required Classes / ZMenuBar.h < prev    next >
Text File  |  1999-02-11  |  8KB  |  286 lines
  1. /*************************************************************************************************
  2. *
  3. *
  4. *            MacZoop - "the framework for the rest of us"         
  5. *
  6. *
  7. *
  8. *            ZMenuBar.h            -- the menubar manager object
  9. *
  10. *
  11. *
  12. *
  13. *
  14. *            © 1996, Graham Cox
  15. *
  16. *
  17. *
  18. *
  19. *************************************************************************************************/
  20.  
  21.  
  22. #pragma once
  23.  
  24. #ifndef __ZMENUBAR__
  25. #define    __ZMENUBAR__
  26.  
  27. #include    "ZComrade.h"
  28. #include    "TextStyleUtils.h"
  29. #include    <Menus.h>
  30.  
  31.  
  32. class    ZArray;
  33.  
  34. // structure for storing info about a menu command
  35.  
  36. typedef struct
  37. {
  38.     long        theCmd;            // item's command
  39.     short        menuID;            // menu ID
  40.     short        itemID;            // item index
  41.     short         cmdFlags;        // associated command flags
  42.     short        subMenuID;        // if parent of submenu, menu we "own".
  43.     MenuHandle    macMenu;        // actual handle of menu that owns this command
  44. }
  45. MenuCmd;
  46.  
  47. // dimming options for entire menus:
  48.  
  49. enum
  50. {
  51.     neverDim = 0,
  52.     dimCommands = 1,
  53.     dimParentItems = 2,
  54.     dimOthers = 4,
  55.     dimAll = 8,
  56.     dimTitle = 32
  57. };
  58.  
  59. typedef unsigned char DimmingOptions;
  60.  
  61.  
  62. // structure for storing info about a whole menu:
  63.  
  64. typedef struct
  65. {
  66.     short            menuID;            // menu ID of the menu
  67.     short            mIndex;            // index into original MBAR resource
  68.     MenuHandle        macMenu;        // handle to the menu
  69.     DimmingOptions    mDimming;        // dimming flags
  70.     Boolean            mIsResource;    // TRUE if menu is a resource
  71. }
  72. MenuInfRec;
  73.  
  74. #if PRAGMA_ALIGN_SUPPORTED
  75. #pragma options align=mac68k
  76. #endif
  77.  
  78. // structure of CMNU resource:
  79.  
  80. typedef struct
  81. {
  82.     short            menuID;
  83.     long            fill1;
  84.     short            procID;
  85.     short            fill2;
  86.     unsigned long    flags;
  87.     char            mTitle;
  88. }
  89. CMNUResource, *CMNUResPtr, **CMNUResHdl;
  90.  
  91. // the items in the menu follow after the title, given the length of the title as
  92. // a number of bytes to skip forward. Each entry consists of the command item text
  93. // followed immediately by four bytes, <icon>, <key equiv>, <mark char>, <style>, 
  94. // followed by command ID (long), followed by next item.
  95.  
  96. typedef struct
  97. {
  98.     unsigned char    iconID;
  99.     unsigned char    keyEqu;
  100.     unsigned char    markChar;
  101.     unsigned char    iStyle;
  102. }
  103. CMNUEntry, *CMNUEntryPtr;
  104.  
  105. // structures used by low-level Mac menu manager:
  106.  
  107. typedef struct
  108. {
  109.     MenuHandle    theMenu;
  110.     short        leftEdge;
  111. }
  112. mListEntry;
  113.  
  114.  
  115. typedef struct
  116. {
  117.     short        lastMOffset;
  118.     short        lastRightEdge;
  119.     short        spare;
  120.     mListEntry    mListItem[1];
  121. }
  122. mList, *mListPtr, **mListHdl;
  123.  
  124.  
  125. #if PRAGMA_ALIGN_SUPPORTED
  126. #pragma options align=reset
  127. #endif
  128.  
  129. // cmd flags
  130.  
  131. enum
  132. {
  133.     nothingSpecial = 0,
  134.     disableCmdsOnly = 1,
  135.     disableAll = 2,
  136.     disableParentItems = 4,
  137.     isPrimaryMenu = 8,
  138.     autoUnCheck = 16,
  139.     menuIsResource = 32
  140. };
  141.  
  142. // special commands
  143.  
  144. enum
  145. {
  146.     noCommand = 0,
  147.     parentCmd = 99
  148. };
  149.  
  150. // constants for AppendStdItems
  151.  
  152. enum
  153. {
  154.     appendDANames = 0,
  155.     appendFontNames
  156. };
  157.  
  158. // constants for menu hiding:
  159.  
  160. typedef enum
  161. {
  162.     MBAR_SHOW,                        // show the menubar
  163.     MBAR_HIDE,                        // hide the menubar
  164.     MBAR_HIDE_MOUSEAWARE            // hide the menu bar unless mouse within 20 pixels of screen top
  165. }
  166. MBarHiding;
  167.  
  168.  
  169.  
  170.  
  171. DEFINECLASSID( ZMenuBar, 'zmbr' );
  172.  
  173. // menubar manager class
  174.  
  175. class    ZMenuBar : public ZComrade
  176. {
  177. protected:
  178.     short            mBarID;                // res ID of original MBAR resource
  179.     short            mbCount;            // number of items in main bar at top level
  180.     short            miSeed;                // index counter
  181.     short            mHelpOffset;        // count of items in help menu before we added any
  182.     short**            mBarH;                // Handle to menubar data during construction
  183.     ZArray*            theMenuCmds;        // array of MenuCmd structs used to map commands
  184.     ZArray*            theMenus;            // array of MenuInfRec structs for menu behaviours
  185.     char            menuCheckChar;        // character used for checking a menu item
  186.     short            wmMenuID;            // ID of windows menu
  187.     short            mBarHeight;            // saved menubar height when hidden
  188.     MBarHiding        mbHiding;            // menubar hiding behaviour
  189.     Boolean            rbPending;            // TRUE if menubar redraw called during dispatch
  190.     Boolean            inDispatch;            // TRUE if currently in dispatch
  191.  
  192. public:
  193.     
  194.     ZMenuBar( const short barID ) : ZComrade() { classID = CLASS_ZMenuBar; mBarID = barID; };
  195.     virtual ~ZMenuBar();
  196.     
  197.     virtual void        InitMenuBar();
  198.     
  199.     virtual void        UpdateMenuBar();
  200.     virtual void        ClickMenuBar( const Point mousePt );
  201.     virtual void        DispatchCommand( const long mSelect );
  202.     virtual void        DimMenus();
  203.     
  204.     virtual void        EnableCommand( const long cmd );
  205.     virtual void        EnableCommand( const short menuID, const short itemID );
  206.     virtual void        DisableCommand( const long cmd );
  207.     virtual void        DisableCommand( const short menuID, const short itemID );
  208.     
  209.     virtual void        CheckCommand( const long cmd, const Boolean checkOnOff );
  210.     virtual void        CheckCommand( const short menuID, const short itemID, const Boolean checkOnOff );
  211.     virtual void        CheckCommand( const short menuID, Str255 itemString, const Boolean checkOnOff );
  212.     virtual void        CheckCommandWithChar( const long cmd, const char checkChar );
  213.     virtual void        CheckCommandWithChar( const short menuID, Str255 itemString, const char checkChar );
  214.     virtual void        SetCommandText( const long cmd, Str255 aText );
  215.     virtual void        SetCommandText( const short menuID, const short itemID, Str255 aText );
  216.     virtual void        SetCommandText( const long cmd, const short strListID, const short strIndex );
  217.     virtual void        SetCommandText( const short menuID, const short itemID, const short strListID, const short strIndex );
  218.     
  219.     virtual void        SetCommandTextStyle( const long cmd, Style aStyle );
  220.     
  221.     virtual void        SetTitleHilite( const short menuID, const Boolean state );
  222.     virtual void        SetMenuDimming( const short menuID, const DimmingOptions dimOpts );
  223.     
  224.     virtual void        AppendMenuToBar( const short menuID );
  225.     virtual void        RemoveMenuFromBar( const short menuID );
  226.     virtual void        AppendStdItems( const short menuID, const short iType = appendDANames );
  227.     virtual MenuHandle    FindMenuID( const short menuID );
  228.     
  229.     virtual short        AppendHelpItem( Str255 itemText );    
  230.     
  231. // automatic "windows" menu handling:
  232.  
  233.     virtual void        NominateWindowsMenu( const short menuID );    
  234.     
  235.     inline    void        SetCheckMarkChar( const char aChar ) { menuCheckChar = aChar; };
  236.     inline  char        GetCheckMarkChar() { return menuCheckChar; };
  237.     
  238. // font, style and size menu utilities, can be called from any UpdateMenus():
  239.  
  240.     virtual void        UpdateStyleMenu( TEStyleRunInfo* runInfo );
  241.     virtual void        UpdateStyleMenu( Style aStyle );
  242.     virtual void        UpdateFontSizeMenu( TEStyleRunInfo* runInfo );
  243.     
  244. // showing and hiding the menubar:
  245.  
  246.     virtual void        ShowHideMenuBar( MBarHiding    mHiding, Point gMouseLoc );
  247.     virtual void        ShowHideMenuBar( MBarHiding    mHiding );
  248.     inline    MBarHiding    GetMenuBarVisState() { return mbHiding; };
  249.     
  250.     virtual void        SetZoomSourceToCommand( const long aCmd );
  251. protected:
  252.     
  253.     virtual void        LoadMenus( const Boolean autoInstall = TRUE );
  254.     
  255.     virtual void        LoadMenu( const short menuID, Boolean isHMenu = FALSE, Boolean autoInstall = TRUE );
  256.     virtual void        LoadCMNUMenu( const short menuID, Boolean isHMenu = FALSE, Boolean autoInstall = TRUE );
  257.     virtual void        UnloadMenu( MenuHandle mH );
  258.     virtual void        PredimMenu( MenuHandle theMenu );
  259.     virtual void        ParseMenuItem( Str255 iText, long* aCmd ); 
  260.     
  261.     virtual void        FindMCmd( const long mSelect, MenuCmd* aCmd );
  262.     virtual void        FindCommand( const long cmd, short* menuID, short* itemID );
  263.  
  264.     virtual long        TrackMenuBar( const Point mouse );
  265.     virtual void        FindMenuInfo( const short menuID, MenuInfRec* mRec );
  266.     virtual void        GetMenuTitleRect( short menuID, Rect* tRect );    
  267. };
  268.  
  269.  
  270. // this object handles a menubar. By default, it calls the mac menu manager to work with the
  271. // global menubar at the top of the main monitor, but it can be subclassed to implement other
  272. // sorts of menubar, for example a mini-menubar in a window (this is left as an exercise!).
  273. // This loads menus and parses the items into a list of command IDs. When the menu item is
  274. // chosen, the associated command is looked up. This is then generally passed up the command
  275. // chain in force at the time.
  276.  
  277. // commands are associated initially with menu items using a #character, so your TCL resources
  278. // etc. can be used directly with this. e.g. "Open File...#12345" will result in the menu item
  279. // "Open File..." and the command number 12345. This will also use CMNU resources (a la MacApp)
  280. // if it can't find a MENU resource. Thus you get the best of both worlds!
  281.  
  282.  
  283. extern    ZMenuBar*    gMenuBar;
  284. extern    short        gFontMenuID;
  285.  
  286. #endif